大数据Spark生态系统 修仙之道 Scala Blog

2019-05-01 Docs Language:简体中文 & English Programing Scala Website:www.geekparkhub.com OpenSource GitHub repo size in bytes GeekDeveloper:JEEP-711 Github:github.com/geekparkhub Gitee:gitee.com/geekparkhub

🐘 Scala Technology 修仙之道 炼精化炁 🐘

Alt text

0. 学习前你需要了解

在继续本教程之前,你应该了解一些基本计算机编程术语.

Spark是新一代基于内存级大数据计算框架,是大数据重要内容.

Spark是基于Scala编程语言构建完成,如果你学习过Java编程语言,将有助于你更快了解掌握Scala编程语言.

1. Scala 概述

Scala是一门多范式(multi-paradigm)编程语言,设计初衷是要集成面向对象编程和函数式编程各种特性.

Scala运行在Java虚拟机上,并兼容现有Java程序.

Scala源代码被编译成Java字节码,所以它可以运行于JVM之上,并可以调用现有Java类库.

Spark的兴起,带动了Scala语言的发展.

2. Scala 语言诞生

创始人马丁 · 奥德斯基(Martin Oderskv)是编译器及编程的狂热爱好者.

长时间的编程之后,希望发明一种语言,能够让写程序这样的基础工作变得高效,简单.

所以当接触到JAVA语言后,对JAVA这门便携式,运行在网络,且存在垃圾回收的语言产生了极大的兴趣,所以决定将函数式编程语言的特点融合到JAVA中.

由此发明了两种语言(Pizza & Scala) / Pizza 和 Scala极大地推动了JAVA编程语言的发展.
jdk5.0泛型,for循环增强,自动类型转换等,都是从Pizza,引入的新特性.

jdk8.0的类型推断,Lambda表达式就是从Scala引入的特性.

且现在主流JVM 的javac编译器就是马丁 · 奥德斯基编写出来的,Jdks5.0 & Jdk8.0的编辑器就是马丁 · 奥德斯基编写的,因此马丁 · 奥德斯基一个人的战斗力抵得上一个JAVA开发团队.

3. Scala 语言特点

Scala是一门以java虚拟机(JVM)为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言.

Scala是一门多范式(multi-paradigm)的编程语言,Scala支持面向对象和函数式编程.

Scala源代码(.scala)会被编译成Java字节码(.class),然后运行于JVM之上，并可以调用现有的Java类库,实现两种语言的无缝对接.

Scala单作为一门语言来看,非常简洁高效(三元运算 / ++ / –).

Scala 在设计时,马丁·奥德斯基是参考了Java的设计思想,可以说Scala是源于java,同时马丁·奥德斯基也加入了自己的思想,将函数式编程语言的特点融合到JAVA中,因此,对于学习过Java的开发者,只要在学习Scala过程中,搞清楚Scala和java相同点和不同点,就可以快速的掌握Scala这门语言.

4. Scala 部署

4.1 MacOs 部署 Scala

systemhub:dev_package system$ pwd

/Users/system/home/work/develop/work_flow/software/dev_package

systemhub:dev_package system$ tar -zxvf scala-2.11.8.tgz -C /Users/system/home/work/develop/work_flow/module/

systemhub:work_flow system$ cd module/

systemhub:module system$ mv scala-2.11.8/ scala

systemhub:module system$ ls -ll

total 0

drwxr-xr-x  10 system  staff  340  2 25 20:52 maven

drwxr-xr-x@ 17 system  staff  578  5  9 11:46 tomcat

drwxr-xr-x  13 system  staff  442  2 28 23:28 hadoop

drwxr-xr-x   6 system  staff  204  3  4  2016 scala

systemhub:module system$

systemhub:module system$ cd scala/

systemhub:scala system$ pwd

/Users/system/home/work/develop/work_flow/module/scala

systemhub:scala system$ sudo vim /etc/profile

## SET SCALA_HOME

export SCALA_HOME=/Users/system/home/work/develop/work_flow/module/scala

export PATH=$PATH:$SCALA_HOME/bin

systemhub:scala system$ source /etc/profile

systemhub:scala system$ scala

Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8).

Type in expressions for evaluation. Or try :help.



scala> print("Hello World!");

Hello World!

scala> :quit

systemhub:scala system$

4.2 Linux 部署 Scala

[root@systemhub511 software]# tar -zxvf scala-2.11.8.tgz -C /opt/module/

[root@systemhub511 module]# mv scala-2.11.8/ scala

[root@systemhub511 module]# ll

total 44

drwxr-xr-x.  9 root  root  4096 Feb 24 21:55 tomcat

drwxr-xr-x.  3 root  root  4096 May 12 16:12 cdh_flow

drwxr-xr-x.  3 root  root  4096 May 20 22:46 datas

drwxr-xr-x. 10 root  root  4096 Apr 11 17:02 flume

drwxr-xr-x.  3 root  root  4096 May  8 20:55 HA

drwxr-xr-x. 12 10011 10011 4096 Mar  3 00:42 hadoop

drwxr-xr-x.  8 root  root  4096 May  6 23:31 hbase

drwxr-xr-x.  8 uucp    143 4096 Dec 20  2017 jdk1.8

drwxr-xr-x.  8 root  root  4096 Apr 17 14:15 kafka

drwxrwxr-x.  6  1001  1001 4096 Mar  4  2016 scala

drwxr-xr-x. 11  1001  1001 4096 Apr 17 13:31 zookeeper

[root@systemhub511 module]# 

[root@systemhub511 module]# cd scala/

[root@systemhub511 scala]# pwd

/opt/module/scala

[root@systemhub511 scala]# vim /etc/profile

## SET SCALA_HOME

export SCALA_HOME=/opt/module/scala

export PATH=$PATH:$SCALA_HOME/bin

[root@systemhub511 scala]# source /etc/profile

[root@systemhub511 module]# scala

Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8).



Type in expressions for evaluation. Or try :help.

scala> print("Hello World!");

Hello World!

scala> :quit

[root@systemhub511 bin]#

5. Scala 插件 For JetBrains IntelliJ IDEA

enter image description here

6. Scala Quick Start

package com.geekparkhub.core.scala.quickstart



/**

  * Geek International Park | 极客国际公园

  * GeekParkHub | 极客实验室

  * Website | https://www.geekparkhub.com/

  * Description | Open开放 · Creation创想 | OpenSource开放成就梦想 GeekParkHub共建前所未见

  * HackerParkHub | 黑客公园枢纽

  * Website | https://www.hackerparkhub.com/

  * Description | 以无所畏惧的探索精神 开创未知技术与对技术的崇拜

  * GeekDeveloper : JEEP-711

  *

  * @author system

  * <p>

  * QuickStartScala

  * <p>

  */



object QuickStartScala {

  def main(args: Array[String]): Unit = {

    println("Scala ~ Hello World!");

  }

}

Scala ~ Hello World!

enter image description here

6.1 反编译 Scala程序 执行流程

6.1.1 Java模拟Scala代码

package com.geekparkhub.core.scala.decompile;



/**

 * Geek International Park | 极客国际公园

 * GeekParkHub | 极客实验室

 * Website | https://www.geekparkhub.com/

 * Description | Open开放 · Creation创想 | OpenSource开放成就梦想 GeekParkHub共建前所未见

 * HackerParkHub | 黑客公园枢纽

 * Website | https://www.hackerparkhub.org/

 * Description | 以无所畏惧的探索精神 开创未知技术与对技术的崇拜

 * GeekDeveloper : JEEP-711

 *

 * @author system

 * <p>

 * QuickStartScala

 *

 * Scala 执行流程

 * 1. object 在底层会生成两个类QuickStartScala,QuickStartScala$

 * 2. `QuickStartScala`中有main函数,调用`QuickStartScala$` 类的一个静态对象 `MODULES$`

 * <p>

 */



public final class QuickStartScala {



    public static void main(String[] paramArrayOfString) {

        // 3. QuickStartScala$.MODULE$. 对象是静态的,通过该对象调用QuickStartScala$的main函数

        QuickStartScala$.MODULE$.main(paramArrayOfString);

    }

}



final class QuickStartScala$ {

    public static final QuickStartScala$ MODULE$;



    static {

        MODULE$ = new QuickStartScala$();

    }



    /**

     * 可以理解为在main函数编写的代码放在QuickStartScala$的main函数中,其实是在底层执行scala编译器做了包装

     * @param args

     */

    public static void main(String[] args) {

        System.out.println("Scala ~ Hello World!");

    }

}

6.1.2 Scala执行流程

enter image description here

6.1.3 Scala程序 开发注意事项 (重点)

6.2 Scala 转义字符

6.3 Scala 语言输出方式

package com.geekparkhub.core.scala.demo



/**

  * Geek International Park | 极客国际公园

  * GeekParkHub | 极客实验室

  * Website | https://www.geekparkhub.com/

  * Description | Open开放 · Creation创想 | OpenSource开放成就梦想 GeekParkHub共建前所未见

  * HackerParkHub | 黑客公园枢纽

  * Website | https://www.hackerparkhub.org/

  * Description | 以无所畏惧的探索精神 开创未知技术与对技术的崇拜

  * GeekDeveloper : JEEP-711

  *

  * @author system

  * <p>

  *  DemoTest

  * <p>

  */



object DemoTest {

  def main(args: Array[String]): Unit = {



    /**

      * String stitching output

      * 字符串拼接 输出

      */

    val parameter1: String = "Hello "

    var parameter2: String = "World!"

    println(parameter1 + parameter2)



    /**

      * Dividing line

      * 分割线

      */

    println(s"-----------------------------------------------------------------------------------------")



    /**

      * Printf formatted output

      * printf格式化 输出

      */

    var name: String = "TestUser001"

    var age: Int = 66;

    var investment: Float = 722.37f

    var assets: Double = 777777777.158

    printf("name is = %s | age is  = %d | investment is = %.2f | assets is = %.3f", name, age, investment, assets)



    /**

      * Dividing line

      * 分割线

      */

    println(s"\n-----------------------------------------------------------------------------------------")



    /**

      * String + $ output

      * 字符串+$ 输出

      */

    println(s"Demo1 info : \n name is  = $name \n age is = $age \n investment is = $investment \n assets is = $assets")



    /**

      * Dividing line

      * 分割线

      */

    println(s"-----------------------------------------------------------------------------------------")



    /**

      * Expression +$ output

      * 表达式+$ 输出

      */

    println(s"Demo2 info : \n name is  = $name \n age is = $age \n investment is = ${investment + 10} \n assets is = ${assets * 20}")

  }

}

Hello World!

-----------------------------------------------------------------------------------------

name is = TestUser001 | age is  = 66 | investment is = 722.37 | assets is = 777777777.158

-----------------------------------------------------------------------------------------

Demo1 info : 

 name is  = TestUser001 

 age is = 66 

 investment is = 722.37 

 assets is = 7.77777777158E8

-----------------------------------------------------------------------------------------

Demo2 info : 

 name is  = TestUser001 

 age is = 66 

 investment is = 732.37 

 assets is = 1.555555554316E10

6.4 Scala 注释 (comment)

6.5 Scala 代码规范说明

/** Contains a fallback builder for arrays when the element type

 *  does not have a class tag. In that case a generic array is built.

 */

class FallbackArrayBuilding {



  /** A builder factory that generates a generic array.

   *  Called instead of `Array.newBuilder` if the element type of an array

   *  does not have a class tag. Note that fallbackBuilder factory

   *  needs an implicit parameter (otherwise it would not be dominated in

   *  implicit search by `Array.canBuildFrom`). We make sure that

   *  implicit search is always successful.

   */

  implicit def fallbackCanBuildFrom[T](implicit m: DummyImplicit): CanBuildFrom[Array[_], T, ArraySeq[T]] =

    new CanBuildFrom[Array[_], T, ArraySeq[T]] {

      def apply(from: Array[_]) = ArraySeq.newBuilder[T]

      def apply() = ArraySeq.newBuilder[T]

    }

}

6.6 Scala 官方API指南

Scala 官方API指南 : scala-lang.org/api/2.11.8

6.7 Scala 变量

变量使用基本步骤

Scala 变量基本使用

var age : Int = 10

var sal : Double = 10.9

var name : String = "tom"

var isPass : Boolean = true

var score : Float = 70.9f

Scala 变量使用说明

6.8 Scala 数据类型

6.8.1 Scala 数据类型体系

enter image description here

6.8.2 Scala 数据类型列表

数据类型 描述
Byte 8位有符号补码整数
Short 16位有符号补码整数
Int 32位有符号补码整数
Long 64位有符号补码整数
Float 32位标准单精度浮点数
Double 64位标准单精度浮点数
Char 16位无符号Unicode字符
String 字符序列
Boolean true / false
Unit 表示无值等同于void
Null null
Nothing 任何其他类型的子类型
Any 所有类的超类
AnyRef 引用类的基类

6.8.3 Scala 整形数据类型

数据类型 描述
Byte [1] 8位有符号补码整数,数值区间为-128到127
Short [2] 16位有符号补码整数,数值区间为-32768到32767
Int [4] 32位有符号补码整数,数值区间为-2147483648到2147483647
Long [8] 64位有符号补码整数,数值区间为-9223372036854775808到9223372036854775807=2的(64-1)次方-1

6.8.4 Scala 浮点数据类型

数据类型 描述
Float [4] 32位标准单精度浮点数
Double [8] 64位标准双精度浮点数

6.8.5 Scala (Char) 字符数据类型

6.8.6 Scala (Boolean) 布尔数据类型

6.8.7 Scala (Unit / Null / Nothing) 数据类型

数据类型 描述
Unit 表示无值等同于void
Null null,Null类型只有一个实例null
Nothing 任何其他类型的子类型

6.8.8 Scala 值类型转换

6.8.8.1 值类型隐式转换
6.8.8.2 高级隐式转换和隐式函数
6.8.8.3 强制类型转换
java : int num = (int)2.5

scala : var num : Int = 2.7.toInt //对象

object DemoTest002 {

  def main(args: Array[String]): Unit = {

    val num1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt

    val num2: Int = (10 * 3.5 + 6 * 1.5).toInt

    println(num1 +" - "+num2)

  }

}
6.8.8.4 数据类型转换 实例
1. var s : Short = 5 //ok

s = s-2 //error Int -> Short



2. var b : Byte = 3 //ok

b = b + 4 // error Int ->Byte

b = (b+4).toByte // ok,使用强制转换



3. var c : Char = 'a' //ok

var i : Int = 5 //ok

var d : Float = .314F //ok

var result : Double = c+i+d //ok Float->Double



4. var b : Byte = 5 //ok

var s : Short = 3 //ok

var t : Short = s + b //error Int->Short

var t2 = s + b //ok,使用类型推导
6.8.8.5 值类型和String类型转换
    // 基本类型转String类型

    val d1 = 1.2

    val s1 = d1 + ""

    println(d1 +" ~ "+ s1)

    // String类型转基本数据类型

    val s2 = "11"

    val int: Int = s2.toInt

    val byte: Byte = s2.toByte

    val double: Double = s2.toDouble

    val long: Long = s2.toLong

    println(s2 +" ~ "+ int +" ~ "+ byte +" ~ "+ double +" ~ "+ long)
6.8.8.6 标识符命名规范
6.8.8.6.1 标识符概念
6.8.8.6.2 标识符命名规则
6.8.8.6.3 标识符举例说明
    // 首字符为操作符(比如+ -* /),后续字符也需跟操作符,至少一个

    val ++ = "hello,scala"

    println(++)



    val -+*/ = 90

    println(-+*/)



    val `true` = "hello"

    println(`true`)
6.8.8.6.4 标识符命名注意事项
6.8.8.6.5 Scala 39个关键字
package, import, class, object, trait, extends, with, type, forSome

private, protected, abstract, sealed, final, implicit, lazy, override

try, catch, finally, throw

if, else, match, case, do, while, for, return, yield

true, false, null

def, val, var

this, super

new

6.9 Scala 运算符

6.9.1 运算符介绍

6.9.2 算术运算符

运算符 运算 范例 结果
+ 正号 +1 1
- 负号 b=4; -b -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 5/5 1
% 取余 7%5 2
+ 字符串相加 “he”+”llo” “hello”
    // 除法 算数运算使用

    val r1: Int = 10 /3

    val r2: Double = 10 /3

    val r3: Double = 10.0 /3

    println(r1 +" ~ "+ r2 +" ~ " + r3 + " ~ " +r3.formatted("%.2f"))



    // 取余 算数运算使用 | 取余运算原则 : a % b = a - a/b * b

    println(10 % 3)

    println(10 % -3)

    println(-10 % 3)

    println(-10 % -3)

6.9.3 关系运算符 (比较运算符)

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true

6.9.4 逻辑运算符

运算符 运算 范例 结果
&& 逻辑与 (A&&B) false
或 逻辑或 (A或B) true
! 逻辑非 !(A&&B) true

6.9.5 赋值运算符

运算符 运算 范例 结果
= 将值赋给左值 C = A + B 将A+B结果赋值为C
+= 相加后再赋值 C += A C = C + A
-= 相减后再赋值 C -= A C = C - A
*= 相乘后再赋值 C *= A C = C * A
/= 相除后再赋值 C /= A C = C / A
%= 取余后再赋值 C %= A C = C % A
<<= 左移后再赋值 C <<= 2 C = C << 2
>>= 右移后再赋值 C >>= 2 C = C >> 2
&= 按位与再赋值 C $= 2 C = C & 2
^= 按位异或后再赋值 C ^= 2 C = C ^ 2
或= 按位或后再赋值 C 或= 2 C = C 或 2
运算符 运算 范例 结果
& 按位与运算符 (a&b) 结果12,二进制0000 1100
或 按位或与运算符 (a或b) 结果61,二进制0011 1101
^ 按位异或运算符 (a^b) 结果49,二进制0011 0001
~ 按位取反运算符 (~a) 结果-61,二进制1100 0011,在一个有符号二进制数的补码形式
<< 左移动运算符 a<<2 结果240,二进制1111 0000
>> 右移动运算符 a>>2 结果15,二进制0000 1111
>>> 无符号右移 A>>>2 结果,二进制0000 1111

6.9.6 运算符优先级

6.9.7 键盘输入语句

object DemoTest003 {

  def main(args: Array[String]): Unit = {

    println("Please type in your name")

    val name = StdIn.readLine()

    println("Please enter age")

    val age = StdIn.readInt()

    println("Please enter the height")

    val height = StdIn.readDouble()

    printf("Your input information is : name=%s age=%d height=%.2f", name, age, height)

  }

}

6.10 Scala 程序流程控制

6.10.1 分支控制 if-else

6.10.1.1 单分支
if(条件表达式){

   执行代码块

}

object DemoTest004 {

  def main(args: Array[String]): Unit = {

    println("Please enter age")

    val age = StdIn.readInt()

    if (age > 18) {

      printf("age > " + age)

    }

  }

}
6.10.1.2 双分支
if (条件表达式) {

    执行代码块1

} else {

    执行代码块2

}

object DemoTest004 {

  def main(args: Array[String]): Unit = {

    val ages = 17

    if (ages > 18) {

      println(ages + " > 17")

    } else {

      println(ages + " < 17")

    }

  }

}
6.10.1.3 多分支
if (条件表达式1) {

    执行代码块1

} else if (条件表达式2) {

    执行代码块2

} 

......

else {

执行代码块n

}

object DemoTest005 {

  def main(args: Array[String]): Unit = {

    while (true) {

      println("------------")

      println("请输入修仙等级")

      println("------------")

      val grade = StdIn.readInt()

      if (grade == 100) {

        println("+++++++")

        println("登峰造极")

      } else if (grade > 80 && grade <= 99) {

        println("+++++++")

        println("炉火纯青")

      } else if (grade >= 60 && grade <= 80) {

        println("+++++++")

        println("热化提纯")

      } else {

        println("+++++++")

        println("无名小卒")

      }

    }

  }

}
6.10.1.4 分支控制if-else 注意事项

6.10.2 嵌套分支

if(){

 if(){

} else {

 }

}

object DemoTest006 {

  def main(args: Array[String]): Unit = {

    println("请输入你的年龄")

    val age = StdIn.readInt()

    if (age >= 18) {

      println("你的年龄大于18岁,请输入你的性别")

      val sex = StdIn.readChar()

      if (sex == '男') {

        println("已进入男子竞技频道")

      } else {

        println("已进入女子竞技频道")

      }

    } else {

      println("你的年龄小于18岁,游戏结束")

    }

  }

}

6.10.3 switch 分支结构

6.10.4 for 循环控制

6.10.4.1 范围数据循环方式 1
for(i <-1 to 3){

 print(i + " ")

}

object DemoTest007 {

  def main(args: Array[String]): Unit = {

    val start = 1

    val end = 10

    for (i <- start to end) {

      println(i + " - hello")

    }

  }

}
6.10.4.2 范围数据循环方式 2
for(i <-1 until 3) {

  print(i + " ")

}

object DemoTest007 {

  def main(args: Array[String]): Unit = {

    val start = 1

    val end = 10

    for (i <- start until end) {

      println(i + " - hey")

    }

  }

}
6.10.4.3 循环守卫
for(i <- 1 to 3 if i != 2) {

 print(i + " ")

}

 object DemoTest007 {

  def main(args: Array[String]): Unit = {

    for (i <- 1 to 3 if i !=2){

      println("num is = " + i)

    }

  }

}
6.10.4.4 引入变量
for(i <-1 to 3; j = 4 -i) {

 print(j + " ")

}

object DemoTest007 {

  def main(args: Array[String]): Unit = {

    for(i <- 1 to 3 ; j = 4 - i){

      println("num j is = " + j)

    }

  }

}
6.10.4.5 嵌套循环
for(i <-1 to 3; j <-1 to 3) {

 println(" i =" + i + " j = " + j)

}

object DemoTest007 {

  def main(args: Array[String]): Unit = {

    for (i <- 1 to 3 ; j <- 1 to 5){

      println("i is = " + i + " , " + "j is = " + j)

    }

  }
6.10.4.6 循环返回值
val res = for(i <-1 to 10) yield i

println(res)

object DemoTest007 {

  def main(args: Array[String]): Unit = {

    /**

      * 对1 to 10 进行遍历

      * yield i 将每次循环得到i放入到集合Vector中,并返回给res

      */

    val res = for (i <- 1 to 10) yield {

      if (i % 2 == 0) {

        i

      } else {

        0

      }

    }

    println(res)

  }

}
6.10.4.7 使用花括号{}代替小括号()
for(i <-1 to 3; j = i * 2) {

 println(" i= " + i + " j= " + j)

}

println("------------------------------------")

for {

  i <-1 to 3

  j = i * 2} {

  println(" i= " + i + " j= " + j)

}
6.10.4.8 注意事项和细节说明
for (i <- Range(1,10,2)){

  println(i)

}

for (i <- 1 to 10 if i % 2 == 1) {

 println(i)

}

6.10.5 while 循环控制

while (循环条件) {

循环体(语句)

循环变量迭代

}

var i = 0

while (i < 10){

 println(i)

 i += 1

}

6.10.6 do..while 循环控制

do{

循环体(语句)

循环变量迭代

} while(循环条件)

var is = 0

do{

 println(is)

 is += 1

} while (is < 10)

6.10.7 多重循环控制

for (i <- 1 to 9){

 for (j <- 1 to i){

  printf("%d * %d = %d\t",j,i,j*i)

 }

  printf("\n")

}

6.10.8 while 循环中断

    var n = 1

    breakable {

      while (n <= 20) {

        n += 1

        println ("n=" + n)

        if (n == 18) {

          // 使用函数式break函数中断循环

          break()

        }

      }

    }

    println("ok")

6.11 Scala 函数式编程 基础

6.11.1 函数式编程内容

函数式编程基础 :
函数定义/声明
函数运行机制
递归 难点[最短路径,邮差问题,迷宫问题,回溯]
过程
过程

函数式编程高级 :
值函数(函数字面量)
高阶函数
闭包
应用函数
柯里化函数 抽象控制

6.11.2 函数式编程介绍

在学习Scala中将方法 / 函数 / 函数式编程和面向对象编程需要明确 :
1.在scala中方法和函数几乎可以等同(比如定义、使用、运行机制都一样),只是函数使用方式更加的灵活多样.
2.函数式编程是从编程方式(范式)角度来谈,可以这样理解 : 函数式编程把函数当做一等公民,充分利用函数、支持的函数多种使用方式.
3.面向对象编程是以对象为基础的编程方式.
4.在scala中函数式编程和面向对象编程融合在一起.

函数式编程思想
函数式编程是一种”编程范式” (programming paradigm)
它属于”结构化编程”的一种,主要思想是把运算过程尽量写成一系列嵌套函数调用.
函数式编程中,将函数也当做数据类型,因此可以接受函数当作输入(参数)和输出(返回值).
函数式编程中最重要的就是函数.

6.11.3 函数的定义

def 函数名([参数名: 参数类型], ...)[[: 返回值类型] =] {

 语句...

 return 返回值

}

object DemoTest009 {

  def main(args: Array[String]): Unit = {

    val sum: Any = getSum(10, 5, '+')

    println("res is = " + sum)

  }



  // 定义函数/方法

  def getSum(n1: Int, n2: Int, oper: Char) = {

    if (oper == '+') {

      n1 + n2

    } else if (oper == '-') {

      n1 - n2

    } else {

      null

    }

  }

}

6.11.4 函数注意事项

6.11.5 过程

6.11.6 惰性函数

6.11.6.1 Java实现懒加载
public class LazyDemo {

    private String property;



    // 属性也可能是一个数据库连接,文件等资源

    public String getProperty() {

        if (property == null) {

            // 如果没有初始化过,那么进行初始化

            property = initProperty();

        }

        return property;

    }



    private String initProperty() {

        return "property";

    }

}
6.11.6.2 惰性函数介绍
object DemoTest010 {

  def main(args: Array[String]): Unit = {

    lazy val res = sum(10, 20)

    println("-----------------")

    println("res=" + res)

    def sum(n1: Int, n2: Int): Int = {

      println("sum() 执行..")

      return n1 + n2

    }

  }

}

6.11.7 异常

6.11.7.1 Java异常处理
public class JavaExceptionDemo01 {

    public static void main(String[] args) {

        try {

            // 可疑代码

            int i = 0;

            int b = 10;

            int c = b / i;

            // 执行代码时，会抛出ArithmeticException异常

        } catch (ArithmeticException ex) {

            ex.printStackTrace();

        } catch (Exception e) {

            //java中不可以把返回大的异常写在前，否则报错!!

            e.printStackTrace();

        } finally {

            // 最终要执行的代码

            System.out.println("java finally");

        }

        System.out.println("ok~~~继续执行...");

    }

}
6.11.7.2 Java异常处理注意点
6.11.7.3 Scala异常处理
object DemoTest011 {

  def main(args: Array[String]): Unit = {

    try {

      val s = 10 / 0

    } catch {

      /**

        * 在scala中只有一个catch

        * 在catch中有多个case,每个case可以匹配一种异常case ex: ArithmeticException

        * => 关键符号,表示后面是对该异常的处理代码块

        * finally是最终执行

        **/

      case ex: ArithmeticException => println("Trapping arithmetic exception")

      case ex: Exception => println("Capture exception")

    } finally {

      println("Scala finally")

    }

    println("Continue execution")

  }

}
6.11.7.4 Scala异常处理小结
  def main(args: Array[String]): Unit = {

    f11()

  }



  //等同于NumberFormatException.class

  @throws(classOf[NumberFormatException])

  def f11() = {

    "abc".toInt

  }

6.12 Scala 面向对象编程 (基础部分)

6.12.1 类与对象

6.12.1.1 Scala语言是面向对象
object DemoTest013 {

  def main(args: Array[String]): Unit = {

    // 创建对象

    val cat = new CatDemo

    // 给对象属性赋值

    cat.name = "kaka"

    cat.age = 10

    cat.colour = "black"

    printf("Info : %s %d %s",cat.name,cat.age,cat.colour)

  }



  class CatDemo {

    // 定义声明属性

    var name: String = ""

    var age: Int = _

    var colour: String = ""

  }

}
6.12.1.2 类和对象区别和联系
6.12.1.3 如何定义类
[修饰符] class 类名{

 类体

}
6.12.1.4 属性
6.12.1.5 属性/成员变量
类型 _ 对应默认值
Byte / Short / Int / Long 0
Float / Double 0.0
String / 引用类型 null
Bollean false
6.12.1.6 属性高级部分
6.12.1.7 如何创建对象

6.12.2 方法

def 方法名(参数列表) [：返回值类型] = {

 方法体

}

6.12.3 构造器

6.12.3.1 Java 构造器
[修饰符] 方法名(参数列表){

 构造方法体

}
6.12.3.2 Scala 构造器
// 主构造器

class 类名(形参列表) {    

// 类体

def this(形参列表) {

 // 辅助构造器

}



def this(形参列表) {    

 // 辅助构造器可以有多个...

 }

}

object DemoTest015 {

  def main(args: Array[String]): Unit = {

    // 初始化对象

    val people = new People("tom", 18)

    println(people)

  }



  // 创建类

  class People(inName: String, inAge: Int) {

    // 定义属性

    var name: String = inName

    var age: Int = inAge



    // 重写toString方法

    override def toString: String = {

      "name = " + this.name + " , age = " + this.age

    }

  }

}
6.12.3.3 Scala构造器注意事项

6.12.4 属性高级

6.12.4.1 构造器参数
package com.geekparkhub.core.scala.demo



object DemoTest016 {

  def main(args: Array[String]): Unit = {



    val worker = new worker("tom")

    worker.name



    val worker2 = new worker2("jack")

    worker2.inName



    val worker3 = new worker3("macs")

    worker3.inName = "tomcat"

    println(worker3.inName)

  }



  class worker(inName: String) {

    var name = inName

  }



  // 只读属性

  class worker2(val inName: String) {

    var name = inName

  }



  // 可读写属性

  class worker3(var inName: String) {

    var name = inName

  }

}
6.12.4.2 Bean属性
object DemoTest017 {

  def main(args: Array[String]): Unit = {

    val car = new Car()

    car.name = "G500"

    println(car.name)



    car.setName("G630")

    println(car.getName)

  }



  class Car {

    @BeanProperty var name: String = _

  }

}

6.12.5 Scala对象创建流程分析

🔒 尚未解锁 正在探索中… 尽情期待 Blog更新! 🔒

6.13 Scala 面向对象编程 (中级部分)

6.14 Scala 面向对象编程 (高级特性)

6.15 Scala 隐式转换 & 隐式值

6.16 Scala 数据结构 (上) - 集合

6.17 Scala 数据结构 (下) - 集合操作

6.18 Scala 模式匹配

6.19 Scala 函数式编程 高级

6.20 Scala 使用递归方式去思考编程

7. 修仙之道 技术架构迭代 登峰造极之势

Alt text

💡如何对该开源文档进行贡献💡

  1. Blog内容大多是手敲,所以难免会有笔误,你可以帮我找错别字。

  2. 很多知识点我可能没有涉及到,所以你可以对其他知识点进行补充。

  3. 现有的知识点难免存在不完善或者错误,所以你可以对已有知识点的修改/补充。

  4. 💡欢迎贡献各领域开源野生Blog&笔记&文章&片段&分享&创想&OpenSource Project&Code&Code Review

  5. 🙈🙈🙈🙈🙈🙈🙈🙈🙈🙈🙈 issues: geekparkhub.github.io/issues 🙈🙈🙈🙈🙈🙈🙈🙈🙈🙈🙈

希望每一篇文章都能够对读者们提供帮助与提升,这乃是每一位笔者的初衷

💌感谢您的阅读 欢迎您的留言与建议💌

捐助 项目的发展离不开你的支持,请开发者喝杯☕Coffee☕吧!

enter image description here

致谢：

捐助时请备注 UserName

ID UserName Donation Money Consume
1 Object WeChatPay 5RMB 一杯可乐
2 泰迪熊看月亮 AliPay 20RMB 一杯咖啡
3 修仙道长 WeChatPay 10RMB 两杯可乐

License 开源协议

Apache License Version 2.0